home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / falcon / nt_dsp2.lzh / NT_DSP2.MSA / BENCH / F-96 < prev    next >
Encoding:
Text File  |  1988-07-22  |  24.1 KB  |  418 lines
  1.      opt  nomd,mex 
  2.      page 132,60,1,1 
  3. ;*******************************************
  4. ;Motorola Austin DSP Operation  June 30,1988
  5. ;*******************************************
  6. ;DSP96002
  7. ;Peripheral to Memory FFT - 1024 point
  8. ;File name: F-96.
  9. ;**************************************************************************
  10. ;    Maximum sample rate:  954 us at 27.0 MHz
  11. ;    Memory Size: Prog:  317 words ; Data:  6146 words
  12. ;    Number of clock cycles: 25760  (12880 instruction cycles)
  13. ;    Clock Frequency:    27.0MHz
  14. ;    Instruction cycle time:  74.1ns
  15. ;**************************************************************************
  16.  
  17. fftreal2  macro     points,data,odata,coef,ptr1,ptr2,ad 
  18. fftreal2  ident     1,2 
  19. ; 
  20. ; Radix 2 Decimation in Time In-Place Fast Fourier Transform Routine 
  21. ; 
  22. ;    Real input data - normally ordered 
  23. ;        Real data in Y memory 
  24. ;    Complex output data - normally ordered 
  25. ;        Real data in X memory 
  26. ;        Imaginary data in Y memory 
  27. ;    Coefficient lookup table 
  28. ;        -Cosine value in X memory 
  29. ;        -Sine value in Y memory 
  30. ; 
  31. ; Macro Call - fftreal2   points,data,outdata,coef,ptr1,ptr2,ad
  32. ; 
  33. ;    points     number of points (2-32768, power of 2) 
  34. ;    data       start of data buffer 
  35. ;    outdata    output data buffer 
  36. ;    coef    start of sine/cosine table 
  37. ;    ptr1  address of pointer to input data block 1
  38. ;    ptr2  address of pointer to input data block 2
  39. ;    ad    address of memory-mapped a/d
  40. ;
  41. ;    dma set-up
  42. ;
  43.      move #data,x:ptr1             ;set up buffer pointers
  44.      move #data+points,x:ptr2      ;
  45.      move #ad,x:$ffffffde          ;a/d memory location into dma source reg.
  46.      move #0,x:$ffffffdd           ;no offset for source reg.
  47.      move #2*points-1,x:$ffffffdb  ;modulo 2*points for input data collection
  48.      move #1,x:$ffffffd9           ;offset = 1 for data storage
  49.      move #data,x:$ffffffda        ;input data base address
  50.      move #points,x:$ffffffdc      ;dma counter = 1024
  51.      move #$80008036,x:$ffffffd8   ;start dma in block mode
  52. ;
  53. ;    test if dma ready, if so switch buffer pointers
  54. ;
  55. strt jclr #28,x:$ffffffd8,strt     ;wait until dma is done
  56.      move #points,x:$ffffffdc      ;if so, reinitialize dma counter
  57.      move #$80008036,x:$ffffffd8   ;restart dma,
  58.      move ptr1,d1.l                ;and swap buffer pointers
  59.      move ptr2,d1.m                ;
  60.      move d1.l,ptr2                ;
  61.      move d1.m,ptr1                ;
  62. ;
  63.  
  64. ;    do fft
  65.      move ptr2,r0                  ;point to data 
  66.      move #points/4,n0             ;offset between input points 
  67.      move #points-1,m0             ;mod on input pointer 
  68.      move r0,r4                    ;ar' pointer 
  69.      move (r0)+n0                  ;point to br' 
  70.      move r0,r5                    ;br' pointer 
  71.      move (r0)+n0                  ;point to c' 
  72.      move r0,r6                    ;cr', ci' pointer 
  73.      move r4,r0                    ;point r0 back to ar 
  74. ; 
  75. ; Do first and second Radix 2 FFT passes 
  76. ; 
  77. ;    y:ar' = x:ar + x:cr + x:br + x:dr 
  78. ;    y:br' = x:ar + x:cr - x:br - x:dr 
  79. ;    x:cr' = y:ar - x:cr 
  80. ;    y:cr' = x:dr - x:br 
  81. ; 
  82.      move                          y:(r0)+n0,d0.s      ;get ar 
  83.      move                          y:(r0)+n0,d1.s      ;get br 
  84.      move                          y:(r0)+n0,d2.s      ;get cr 
  85.      faddsub d0,d2                 y:(r0)+n0,d3.s      ;cr'=ar-cr,ar+cr,get dr 
  86.      do n0,_first2                                     ;do first 2 passes 
  87.      fsubr d1,d3    d0.s,x:(r6)    d3.s,d4.s           ;dr-br, save cr', copy dr 
  88.      fadd d1,d4     x:(r0)+,d7.s   d3.s,y:(r6)+        ;dr+br, update r0, save ci' 
  89.      faddsub d2,d4                 y:(r0)+n0,d0.s      ;(ar+cr)(-+)(dr+br) 
  90.      move           d2.s,x:(r5)+   y:(r0)+n0,d1.s      ;save br', get br 
  91.      move                          d4.s,y:(r4)+        ;save ar' 
  92.      move                          y:(r0)+n0,d2.s      ;get cr 
  93.      faddsub   d0,d2               y:(r0)+n0,d3.s      ;ar-cr,ar+cr,get dr 
  94. _first2 
  95. ; 
  96. ; Do next passes 
  97. ; 
  98.      move #points/8,n5                            ;spacing, for 1024 spacing=128 
  99.      move ptr2,r2                                 ;pointer to data      
  100.  
  101.      do   #@cvi(@log(points)/@log(2)-2.5),_next   ;7 passes for 1024 pts 
  102.      move r2,r5                                   ;reset pointer to data  
  103.      move n5,n0                                   ;same offset 
  104.      move r5,r0                                   ;ar pointer 
  105.      move (r5)+n5                                 ;+1/4 
  106.      move r5,r4                                   ;br pointer 
  107.      move (r5)+n5                                 ;+1/2 
  108.      move r5,r1                                   ;ci pointer 
  109.      move (r5)+n5                                 ;+3/4 
  110.  
  111.      move           x:(r5)+,d0.s   y:(r0)+n0,d4.s ;get dr, get ar 
  112.      do n0,_inner 
  113.      fneg d0                       y:(r0)-n0,d1.s ;ci'=-dr, get br 
  114.      faddsubr  d4,d1               d0.s,y:(r1)+   ;br'=ar-br,ar'=ar+br, save ci' 
  115.      move           d4.s,x:(r4)+   d1.s,y:(r0)+   ;save br', save ar' 
  116.      move           x:(r5)+,d0.s   y:(r0)+n0,d4.s ;get dr, get ar 
  117. _inner 
  118.      move n5,a                                    ;get bflys/pass 
  119.      lsr  a                                       ;/2 
  120.      move a1,n5                                   ;put back 
  121. _next 
  122.  
  123. ; 
  124. ;    special pass: real input (4-point), output in normal order. The 4-th 
  125. ;    output point is stored as the complex conjugate of the 3 rd.
  126. ;
  127.      move #data,r0                                ;input pointer 
  128.      move #odata,r4                               ;output pointer 
  129.      move #points/2,n4   
  130.      move #0,m4                                   ;bit reverse output 
  131.  
  132.      move                          y:(r0)+,d0.s   ;get ar 
  133.      move                          y:(r0)+,d4.s   ;get br 
  134.      faddsubr d0,d4 x:(r0)+,d1.s                  ;get cr 
  135.      move                          d4.s,y:(r4)+n4 ;save ar'
  136.      move           x:(r0)+,d2.s                  ;get dr
  137.      fneg d2        d2.s,d5.s      d0.s,x:(r4)+n4 ;copy dr, save br' 
  138.      move           d1.s,x:(r4)                   ;save cr' 
  139.      move                          d2.s,y:(r4)+n4 ;save ci' 
  140.      move           d1.s,x:(r4)                   ;save cr' 
  141.      move                          d5.s,y:(r4)+n4 ;save ci'* 
  142.  
  143.  
  144. ;
  145. ;Do first (2-point) complex fft (this has one "last pass" only) with normally ordered
  146. ;output data and conjugate reverse storage of the next two points
  147. ;
  148.      move      #4,n2               ;offset for input data pointer
  149.      move      r4,n7               ;initialize output data pointer
  150.      move      (r2)+n2             ;adjust input data pointer
  151.      move      #0,m6               ;bit-reversed addressing for r6
  152.      move      #coefsize/2,n6
  153.      
  154. ; last pass
  155. ;
  156.       move      r2,r0                   ;Point to input data block
  157.       move      n7,r4                   ;r4 points to A output
  158.       move      #2*odata+points,r3      ;initialization of conjugate reverse pointer
  159.       move      #-1,m3                  ;r3 (conjugate reverse pointer) decrements linearly in initialization
  160.       move      r4,n3                   ;offset for conjugate pointer initialization
  161.       lea       (r0)+,r1                ;r1 points to B input
  162.       move      (r3)-n3                 ;r3 now has end of next output data block
  163.       move      #0,m3                   ;r3 will decrement bit-reversed in output storage
  164.       move      #points/2,n3            ;correct offset for reverse counter
  165.       move      #2,n0                   ;offset is 2 for A input pointer
  166.       lea       (r3)+n3,r6              ;r6 now contains the next output pointer a starting address
  167.       move      r6,n7                   ;n7 contains next output data block starting address
  168.       move      #coef+coefsize/4,r6     ;r6 points to twiddle factors  
  169.       move      n0,n1                   ;offset is 2 for B input pointer
  170.       move      #points/4,n4            ;offset is #points/4 for A output pointer
  171.       move      n4,n5                   ;offset is #points/4 for B output pointer
  172.       move      #0,m4                   ;bit reversed addressing for A output pointer
  173.       lea      (r4)+n4,r5               ;r5 points to B output by adding points/4 once----|
  174.       move      m4,m5                   ;bit reversed addressing for B output pointer     |
  175.       move     (r5)+n5                  ;and once more to odata                     <-----|
  176.       fmove                             x:(r6)+n6,d9.s y:(),d8.s      ;
  177.       fmove                                            y:(r1),d7.s    ;
  178.       fmpy d8,d7,d3                     x:(r1)+n1,d6.s                ;
  179.       fmpy d9,d6,d0                                                   ;
  180.       fmpy d9,d7,d1                                    y:(r1),d7.s    ;
  181.       fmpy d8,d6,d2  fadd d3,d0         x:(r0),d4.s                   ; Last groups are implemented as
  182.       fmove                             x:(r6)+n6,d9.s y:(),d8.s      ; single butterflies with storage to 
  183.       fmpy d8,d7,d3  faddsubr d4,d0     x:(r1)+n1,d6.s                ; the output data buffer. Data is stored 
  184.                                                                       ; in normal order, and the complex conjugate is
  185.                                                                       ; stored in the next output block using the 
  186.       fmpy d9,d6,d0  fsub d1,d2         d0.s,x:(r4)                   ; conjugate reverse counter r3
  187.       fmove                             d0.s,x:(r3)-n3 y:(r0)+n0,d5.s ;
  188.       fmpy d9,d7,d1  faddsubr d5,d2     d4.s,x:(r5)    y:(r1),d7.s    ;
  189.       fmove                             d4.s,x:(r3)+n3 y:(r6),d8.s    ;                                   
  190.       fadd d3,d0                        x:(r0),d4.s    d5.s,y:(r4)+n4 ;
  191.       fneg d5                                          d2.s,y:(r5)+n5 ;
  192.       fneg d2                           x:(r6)+n6,d9.s d5.s,y:(r3)-n3 ;
  193.       fmpy d8,d6,d2                                    d2.s,y:(r3)-n3 ;
  194.       fmpy d8,d7,d3  faddsubr d4,d0     x:(r1)+n1,d6.s                ;
  195. _end_last
  196.  
  197. ;
  198. ;Do second (four-point) complex fft (this has a "next to last" and "last pass"
  199. ;only with normal output storage and conjugate reverse storage of the next four
  200. ;points)
  201. ;
  202.            move (r2)+n2                      ;initialize input data pointer
  203. ;
  204. ; next to last pass
  205. ;
  206.       move #1,n2                        ;initialize number of groups
  207.       move r2,r0                        ;point to input data block
  208.       move r0,r4                        ;initialize pointers and offsets
  209.       lea (r0)+2,r1                     ;
  210.       move r1,r5                        ;
  211.       move #coef+coefsize/4,r6          ;
  212.       move #3,n0                        ;
  213.       move n0,n1                        ;
  214.       move n0,n4                        ;
  215.       move n0,n5                        ;
  216.       fmove                        x:(r6)+n6,d9.s  y:(),d8.s     ;
  217.       fmove                                        y:(r1),d7.s   ;
  218.       fmpy d8,d7,d3                x:(r1)+,d6.s                  ;
  219.       fmpy d9,d6,d0                                              ;
  220.       fmpy d9,d7,d1                                y:(r1),d7.s   ;
  221.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s                   ;
  222.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s                ;                             
  223.       fmpy d9,d6,d0 fsub d1,d2     d0.s,x:(r4)     y:(r0)+,d5.s  ;
  224.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)     y:(r1),d7.s   ;each group implemented as one 
  225.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s     d2.s,y:(r5)+  ;four-point butterfly
  226.       fmove                        x:(r6)+n6,d9.s  y:(),d8.s     ;
  227.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+,d6.s    d5.s,y:(r4)+  ;
  228.       fmpy d9,d6,d0 fsub     d1,d2 d0.s,x:(r4)     y:(r0)+n0,d5.s
  229.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)     y:(r1),d7.s   ;
  230.       fmpy d8,d6,d2 fadd     d3,d0 x:(r0),d4.s     d2.s,y:(r5)+n5
  231.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s  d5.s,y:(r4)+n4
  232. _end_next
  233. ;
  234. ; last pass
  235. ;
  236.       move n2,d0.l                 ;number of groups in last pass=
  237.       lsl d0   r2,r0               ;2*number of groups in previous pass. Point to input data block.
  238.       move d0.l,n2                 ;number of stages in this group -->n2
  239.       move n7,r4                   ;r4 points to A output
  240.       move #2*odata+points,r3      ;initialization of conjugate reverse pointer
  241.       move #-1,m3                  ;r3 (conjugate reverse pointer) decrements linearly in initialization
  242.       move r4,n3                   ;offset for conjugate pointer initialization
  243.       lea (r0)+,r1                 ;r1 points to B input
  244.       move (r3)-n3                 ;r3 now has end of next output data block
  245.       move #0,m3                   ;r3 will decrement bit-reversed in output storage
  246.       move #points/2,n3            ;correct offset for reverse counter
  247.       move #2,n0                   ;offset is 2 for A input pointer
  248.       lea (r3)+n3,r6               ;r6 now contains the next output pointer a starting address
  249.       move r6,n7                   ;n7 contains next output data block starting address
  250.       move #coef+coefsize/4,r6     ;r6 points to twiddle factors  
  251.       move n0,n1                   ;offset is 2 for B input pointer
  252.       move #points/4,n4            ;offset is #points/4 for A output pointer
  253.       move n4,n5                   ;offset is #points/4 for B output pointer
  254.       move #0,m4                   ;bit reversed addressing for A output pointer
  255.       lea (r4)+n4,r5               ;r5 points to B output by adding points/4 once----|
  256.       move m4,m5                   ;bit reversed addressing for B output pointer     |
  257.       move (r5)+n5                 ;and once more to odata                     <-----|
  258.       fmove                        x:(r6)+n6,d9.s  y:(),d8.s          ;
  259.       fmove                                       y:(r1),d7.s         ;
  260.       fmpy d8,d7,d3                x:(r1)+n1,d6.s                     ;
  261.       fmpy d9,d6,d0                                                   ;
  262.       fmpy d9,d7,d1                               y:(r1),d7.s         ;
  263.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s                        ; Last groups are implemented as
  264.       fmove                        x:(r6)+n6,d9.s y:(),d8.s           ; single butterflies with storage to 
  265.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s                     ; the output data buffer. Data is stored 
  266.                                                                       ; in normal order, and the complex conjugate is
  267.       do n2,_end_last                                                 ; stored in the next output block using the 
  268.       fmpy d9,d6,d0 fsub d1,d2     d0.s,x:(r4)                        ; conjugate reverse counter r3
  269.       fmove                        d0.s,x:(r3)-n3  y:(r0)+n0,d5.s     ;
  270.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)     y:(r1),d7.s        ;
  271.       fmove                        d4.s,x:(r3)+n3  y:(r6),d8.s        ;                                   
  272.       fadd d3,d0                   x:(r0),d4.s     d5.s,y:(r4)+n4     ;
  273.       fneg d5                                      d2.s,y:(r5)+n5     ;
  274.       fneg d2                      x:(r6)+n6,d9.s  d5.s,y:(r3)-n3     ;
  275.       fmpy d8,d6,d2                                d2.s,y:(r3)-n3     ;
  276.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s                     ;
  277. _end_last
  278. ;
  279. ;Do all remaining complex fft's (starting with 8-point) with normally ordered
  280. ;output storage and conjugate reverse storage of the next output block
  281. ;
  282.       clr d9                                      ;initialize the # passes      
  283.       move #-1,m2                                 ;linear addressing for input data block pointer
  284.       move #8,n2                                  ;offset=8 for input data ptr.
  285.       move #4,d8                                  ;initialize number of FFT points
  286.       move (r2)+n2                                ;initialize r2  
  287.       do #@cvi(@log(points)/@log(2)-3.5),_endfft  ;do for all fft's. Ex.: 6 for 1024-pt.
  288.       
  289.       lsl d8                            ;new number of FFT pts = number of FFT points * 2
  290.       inc d9                            ;increment # passes
  291.       clr d2         d8.l,d1.l          ;number of FFT points -->d1
  292.       move d2.l,m6                      ;bit-reversed addr. for coef. ptr
  293.       move #1,d0.l                      ;initialize # groups          
  294.       move d8.l,n2                      ;offset for computing new input data block ptr.
  295.       move (r2)+n2                      ;point to next input data block
  296.  
  297.       do d9.l,_end_pass                 ;do for all passes
  298.       move d0.l,n2                      ;load number of groups
  299.       move r2,r0                        ;point to data
  300.       lsr  d1       #coef+coefsize/4,r6 ;# butterflies per group/2,r6 points to first coeff.
  301.       dec  d1      d1.l,n0              ;decrement number of butterflies twice
  302.       dec  d1      d1.l,n1              ;(first two butterflies are done separately)
  303.       move d1.l,n3                      ;number of butterflies per group-->n3
  304.       move n0,n4                        ;initialize pointers and pointer offsets
  305.       move n0,n5                        ;
  306.       lea (r0)+n0,r1                    ;
  307.       move r0,r4                        ;
  308.       move r1,r5                        ;
  309.       fmove                        x:(r6)+n6,d9.s y:(),d8.s      ;first two
  310.       fmove                                       y:(r1),d7.s    ;butterflies in this
  311.       fmpy d8,d7,d3                x:(r1)+,d6.s                  ;pass
  312.       fmpy d9,d6,d0                                              ;
  313.       fmpy d9,d7,d1                                 y:(r1),d7.s  ;
  314.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s                   ;
  315.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+,d6.s                  ;
  316.  
  317.       do n2,_end_grp          ;do for all groups in this pass
  318.  
  319.       do n3,_end_bfy          ;do for all butterflies in this group
  320.       fmpy d9,d6,d0 fsub d1,d2     d0.s,x:(r4)    y:(r0)+,d5.s   ;4-instruction butterfly with
  321.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)    y:(r1),d7.s    ;constant twiddle
  322.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s    d2.s,y:(r5)+   ;factor
  323.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+,d6.s   d5.s,y:(r4)+   ;
  324. _end_bfy
  325.       move (r1)+n1                                               ;first two
  326.       fmpy d9,d6,d0 fsub d1,d2     d0.s,x:(r4)    y:(r0)+,d5.s   ;butterflies in next
  327.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)    y:(r1),d7.s    ;pass
  328.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s    d2.s,y:(r5)+   ;
  329.       fmove                        x:(r6)+n6,d9.s y:(),d8.s      ;
  330.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+,d6.s   d5.s,y:(r4)+   ;
  331.       fmpy d9,d6,d0 fsub     d1,d2 d0.s,x:(r4)    y:(r0)+n0,d5.s ;
  332.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)    y:(r1),d7.s    ;
  333.       fmpy d8,d6,d2 fadd     d3,d0 x:(r0),d4.s    d2.s,y:(r5)+n5 ;
  334.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+,d6.s   d5.s,y:(r4)+n4 ;
  335. _end_grp
  336.       move n2,d0.l                      ;number of groups for next pass=
  337.       lsl d0        n0,d1.l             ;2*number of groups for this pass
  338. _end_pass
  339. ;
  340. ; next to last pass
  341. ;
  342.       move      d0.l,n2            ;initialize number of groups
  343.       move      r2,r0              ;point to input data block
  344.       move      r0,r4              ;initialize pointers and offsets
  345.       lea      (r0)+2,r1           ;
  346.       move      r1,r5              ;
  347.       move      #coef+points/4,r6  ;
  348.       move      #3,n0              ;
  349.       move      n0,n1              ;
  350.       move      n0,n4              ;
  351.       move      n0,n5              ;
  352.       fmove                        x:(r6)+n6,d9.s y:(),d8.s      ;
  353.       fmove                                       y:(r1),d7.s    ;
  354.       fmpy d8,d7,d3                x:(r1)+,d6.s                  ;
  355.       fmpy d9,d6,d0                                              ;
  356.       fmpy d9,d7,d1                               y:(r1),d7.s    ;
  357.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s                   ;
  358.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s                ;
  359.                               
  360.       do n2,_end_next                                            ;do for all groups
  361.       fmpy d9,d6,d0 fsub d1,d2     d0.s,x:(r4)    y:(r0)+,d5.s   ;
  362.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)    y:(r1),d7.s    ;each group implemented as one 
  363.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s    d2.s,y:(r5)+   ;four-point butterfly
  364.       fmove                        x:(r6)+n6,d9.s y:(),d8.s      ;
  365.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+,d6.s   d5.s,y:(r4)+   ;
  366.       fmpy d9,d6,d0 fsub d1,d2     d0.s,x:(r4)    y:(r0)+n0,d5.s
  367.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)    y:(r1),d7.s    ;
  368.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s    d2.s,y:(r5)+n5
  369.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s d5.s,y:(r4)+n4
  370. _end_next
  371. ;
  372. ; last pass
  373. ;
  374.       move n2,d0.l            ;number of groups in last pass=
  375.       lsl d0        r2,r0     ;2*number of groups in previous pass. Point to input data block.
  376.       move d0.l,n2            ;number of stages in this group -->n2
  377.       move n7,r4              ;r4 points to A output
  378.       move #2*odata+points,r3 ;initialization of conjugate reverse pointer
  379.       move #-1,m3             ;r3 (conjugate reverse pointer) decrements linearly in initialization
  380.       move r4,n3              ;offset for conjugate pointer initialization
  381.       lea (r0)+,r1            ;r1 points to B input
  382.       move (r3)-n3            ;r3 now has end of next output data block
  383.       move #0,m3              ;r3 will decrement bit-reversed in output storage
  384.       move #points/2,n3       ;correct offset for reverse counter
  385.       move #2,n0              ;offset is 2 for A input pointer
  386.       lea (r3)+n3,r6          ;r6 now contains the next output pointer a starting address
  387.       move r6,n7              ;n7 contains next output data block starting address
  388.       move #coef+points/4,r6  ;r6 points to twiddle factors  
  389.       move n0,n1              ;offset is 2 for B input pointer
  390.       move #points/4,n4       ;offset is #points/4 for A output pointer
  391.       move n4,n5              ;offset is #points/4 for B output pointer
  392.       move #0,m4              ;bit reversed addressing for A output pointer
  393.       lea (r4)+n4,r5          ;r5 points to B output by adding points/4 once----|
  394.       move m4,m5              ;bit reversed addressing for B output pointer     |
  395.       move (r5)+n5            ;and once more to odata                     <-----|
  396.       fmove                        x:(r6)+n6,d9.s y:(),d8.s           ;
  397.       fmove                                       y:(r1),d7.s         ;
  398.       fmpy d8,d7,d3                x:(r1)+n1,d6.s                     ;
  399.       fmpy d9,d6,d0                                                   ;
  400.       fmpy d9,d7,d1                                y:(r1),d7.s        ;
  401.       fmpy d8,d6,d2 fadd d3,d0     x:(r0),d4.s                        ; Last groups are implemented as
  402.       fmove                        x:(r6)+n6,d9.s  y:(),d8.s          ; single butterflies with storage to 
  403.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s                     ; the output data buffer. Data is stored 
  404.                                                                       ; in normal order, and the complex conjugate is
  405.       do n2,_end_last                                                 ; stored in the next output block using the 
  406.       fmpy d9,d6,d0 fsub d1,d2     d0.s,x:(r4)                        ; conjugate reverse counter r3
  407.       fmove                        d0.s,x:(r3)-n3  y:(r0)+n0,d5.s     ;
  408.       fmpy d9,d7,d1 faddsubr d5,d2 d4.s,x:(r5)     y:(r1),d7.s        ;
  409.       fmove                        d4.s,x:(r3)+n3  y:(r6),d8.s        ;                                   
  410.       fadd d3,d0                   x:(r0),d4.s     d5.s,y:(r4)+n4     ;
  411.       fneg d5                                      d2.s,y:(r5)+n5     ;
  412.       fneg d2                      x:(r6)+n6,d9.s  d5.s,y:(r3)-n3     ;
  413.       fmpy d8,d6,d2                                d2.s,y:(r3)-n3     ;
  414.       fmpy d8,d7,d3 faddsubr d4,d0 x:(r1)+n1,d6.s                     ;
  415. _end_last
  416. _endfft
  417.      jmp  strt           ;go back and start new fft
  418.